home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / flight-of-the-museum.swf / scripts / engine / dynamicObjects / DynamicObject.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  14.3 KB  |  525 lines

  1. package engine.dynamicObjects
  2. {
  3.    import engine.WorldScene;
  4.    import flash.display.BitmapData;
  5.    import flash.geom.Matrix;
  6.    import flash.geom.Point;
  7.    import flash.geom.Rectangle;
  8.    
  9.    public class DynamicObject
  10.    {
  11.        
  12.       
  13.       protected var _auditMeter:Number = 0;
  14.       
  15.       protected var _explodes:Boolean = false;
  16.       
  17.       public var hitH:Number = 35;
  18.       
  19.       public var destroyed:Boolean = false;
  20.       
  21.       public var vis:Boolean = true;
  22.       
  23.       public var hitW:Number = 35;
  24.       
  25.       protected var DMETHOD:Object;
  26.       
  27.       protected var _shrapnelCount:Number = 0;
  28.       
  29.       protected var _shrapnelType:Boolean = false;
  30.       
  31.       protected var _blendMode:String;
  32.       
  33.       protected var _persistent:Boolean = false;
  34.       
  35.       protected var _animationMethod:Number = 0;
  36.       
  37.       protected var _currentFrame:Number = 1;
  38.       
  39.       protected var _drawDepth:Number = 1;
  40.       
  41.       public var pxd:Number = 1;
  42.       
  43.       protected var ANIM_METHODS:Object;
  44.       
  45.       public var yflip:Number = 1;
  46.       
  47.       protected var _lockScale:Boolean = false;
  48.       
  49.       public var h:Number = 0;
  50.       
  51.       public var r:Number = 0;
  52.       
  53.       public var s:Number = 1;
  54.       
  55.       public var w:Number = 0;
  56.       
  57.       public var x:Number = 0;
  58.       
  59.       public var y:Number = 0;
  60.       
  61.       public var z:Number = 1;
  62.       
  63.       public var pyd:Number = 1;
  64.       
  65.       protected var _collisionMethod:Number = 0;
  66.       
  67.       protected var _loopDelayMax:* = 0;
  68.       
  69.       public var colOffsetX:Number = 0;
  70.       
  71.       public var colOffsetY:Number = 0;
  72.       
  73.       public var lockY:Boolean = false;
  74.       
  75.       protected var _frameSpeed:Number = 0;
  76.       
  77.       public var lockX:Boolean = false;
  78.       
  79.       protected var _loopFrame:Number = 1;
  80.       
  81.       public var solid:Boolean = false;
  82.       
  83.       protected var COLLISION_METHOD:Object;
  84.       
  85.       protected var _shrapnelVel:Number = 0;
  86.       
  87.       protected var _objectType:Number = -1;
  88.       
  89.       protected var _bmd:BitmapData;
  90.       
  91.       public var roX:Number = 0;
  92.       
  93.       public var roY:Number = 0;
  94.       
  95.       protected var _bmdArray:Array;
  96.       
  97.       public var vx:Number = 0;
  98.       
  99.       public var vy:Number = 0;
  100.       
  101.       public var vz:Number = 0;
  102.       
  103.       protected var _collectable:Boolean = false;
  104.       
  105.       protected var _loopDelay:* = 0;
  106.       
  107.       protected var _collisionBitmap:BitmapData;
  108.       
  109.       protected var _dangerous:Boolean = false;
  110.       
  111.       protected var _matrix:Matrix;
  112.       
  113.       public var xflip:Number = 1;
  114.       
  115.       protected var _drawMethod:int;
  116.       
  117.       protected var OBJ_TYPES:Object;
  118.       
  119.       protected var _auditThreshhold:Number = 10;
  120.       
  121.       private var _cameraFocus:Boolean = false;
  122.       
  123.       protected var _scfl:Number;
  124.       
  125.       public function DynamicObject(inBmd:BitmapData = null)
  126.       {
  127.          ANIM_METHODS = {
  128.             "PlayOnce":0,
  129.             "Loop":1,
  130.             "Arbitrary":2,
  131.             "LoopWithRandomDelay":3,
  132.             "PlayOncePersistent":4
  133.          };
  134.          OBJ_TYPES = {
  135.             "FX":0,
  136.             "GP":1,
  137.             "SC":2
  138.          };
  139.          DMETHOD = {
  140.             "Pixel":0,
  141.             "Fast":1,
  142.             "Slow":2
  143.          };
  144.          COLLISION_METHOD = {
  145.             "VisibleIntersect":0,
  146.             "Radial":1
  147.          };
  148.          _drawDepth = 1;
  149.          _lockScale = false;
  150.          _currentFrame = 1;
  151.          _loopFrame = 1;
  152.          _loopDelay = 0;
  153.          _loopDelayMax = 0;
  154.          _frameSpeed = 0;
  155.          _animationMethod = 0;
  156.          _collisionMethod = 0;
  157.          _objectType = -1;
  158.          x = 0;
  159.          y = 0;
  160.          z = 1;
  161.          vx = 0;
  162.          vy = 0;
  163.          vz = 0;
  164.          r = 0;
  165.          s = 1;
  166.          w = 0;
  167.          h = 0;
  168.          hitW = 35;
  169.          hitH = 35;
  170.          roX = 0;
  171.          roY = 0;
  172.          colOffsetX = 0;
  173.          colOffsetY = 0;
  174.          vis = true;
  175.          solid = false;
  176.          lockX = false;
  177.          lockY = false;
  178.          destroyed = false;
  179.          pxd = 1;
  180.          pyd = 1;
  181.          xflip = 1;
  182.          yflip = 1;
  183.          _matrix = new Matrix();
  184.          _auditThreshhold = 10;
  185.          _auditMeter = 0;
  186.          _persistent = false;
  187.          _collectable = false;
  188.          _explodes = false;
  189.          _dangerous = false;
  190.          _shrapnelType = false;
  191.          _shrapnelCount = 0;
  192.          _shrapnelVel = 0;
  193.          _cameraFocus = false;
  194.          super();
  195.          _bmd = inBmd;
  196.          if(_bmd)
  197.          {
  198.             w = _bmd.width;
  199.             h = _bmd.height;
  200.          }
  201.          else
  202.          {
  203.             trace("### ERROR: DynamicObject has no assigned graphic");
  204.          }
  205.          _scfl = WorldScene.Instance.Con.SC_FOCAL_LENGTH;
  206.       }
  207.       
  208.       private function pixelDraw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  209.       {
  210.       }
  211.       
  212.       protected function getFullBoundsCollisionMap() : *
  213.       {
  214.          _collisionBitmap = new BitmapData(w,h,false,16711680);
  215.          trace("getFullBoundsCollisionMap - w: " + w + " h: " + h + " _collisionBitmap: " + _collisionBitmap);
  216.       }
  217.       
  218.       public function get AuditThreshhold() : Number
  219.       {
  220.          return _auditThreshhold;
  221.       }
  222.       
  223.       public function set AuditMeter(inVal:Number) : *
  224.       {
  225.          if(!_persistent)
  226.          {
  227.             _auditMeter = inVal;
  228.          }
  229.       }
  230.       
  231.       public function set CameraFocus(inVal:Boolean) : *
  232.       {
  233.          _cameraFocus = inVal;
  234.       }
  235.       
  236.       protected function getVector(inRadians:Number, inVelocity:Number) : Object
  237.       {
  238.          var vX:Number = NaN;
  239.          var vY:Number = NaN;
  240.          vX = inVelocity * Math.cos(inRadians);
  241.          vY = inVelocity * Math.sin(inRadians);
  242.          return {
  243.             "x":vX,
  244.             "y":vY
  245.          };
  246.       }
  247.       
  248.       protected function getRadians(inSourceX:Number, inSourceY:Number, inTargetX:Number, inTargetY:Number) : Number
  249.       {
  250.          return Math.atan2(inTargetY - inSourceY,inTargetX - inSourceX);
  251.       }
  252.       
  253.       public function draw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  254.       {
  255.          switch(_drawMethod)
  256.          {
  257.             case DMETHOD.Pixel:
  258.                pixelDraw(inBitmap,inCamX,inCamY);
  259.                break;
  260.             case DMETHOD.Fast:
  261.                fastDraw(inBitmap,inCamX,inCamY);
  262.                break;
  263.             case DMETHOD.Slow:
  264.                slowDraw(inBitmap,inCamX,inCamY);
  265.                break;
  266.             default:
  267.                trace("### ERROR Dynamic object has no draw method set");
  268.          }
  269.       }
  270.       
  271.       public function fStep() : *
  272.       {
  273.          var cf:Number = NaN;
  274.          x += vx;
  275.          y += vy;
  276.          z += vz;
  277.          if(z < 1)
  278.          {
  279.             z = 1;
  280.          }
  281.          if(_bmdArray)
  282.          {
  283.             switch(_animationMethod)
  284.             {
  285.                case ANIM_METHODS.PlayOnce:
  286.                   _currentFrame += _frameSpeed;
  287.                   if(_currentFrame >= _bmdArray.length)
  288.                   {
  289.                      _currentFrame = _bmdArray.length;
  290.                      destroy();
  291.                   }
  292.                   break;
  293.                case ANIM_METHODS.PlayOncePersistent:
  294.                   _currentFrame += _frameSpeed;
  295.                   if(_currentFrame >= _bmdArray.length)
  296.                   {
  297.                      _currentFrame = _bmdArray.length;
  298.                   }
  299.                   break;
  300.                case ANIM_METHODS.Loop:
  301.                   _currentFrame += _frameSpeed;
  302.                   if(_currentFrame > _bmdArray.length)
  303.                   {
  304.                      _currentFrame = _loopFrame;
  305.                   }
  306.                   break;
  307.                case ANIM_METHODS.Arbitrary:
  308.                   if(_currentFrame > _bmdArray.length)
  309.                   {
  310.                      _currentFrame = _bmdArray.length;
  311.                   }
  312.                   if(_currentFrame < 1)
  313.                   {
  314.                      _currentFrame = 1;
  315.                   }
  316.                   break;
  317.                case ANIM_METHODS.LoopWithRandomDelay:
  318.                   --_loopDelay;
  319.                   _currentFrame += _frameSpeed;
  320.                   if(_currentFrame > _bmdArray.length)
  321.                   {
  322.                      _loopDelay = _loopDelayMax / 4 + Math.random() * _loopDelayMax;
  323.                      _currentFrame = _loopFrame;
  324.                      _frameSpeed = 0;
  325.                   }
  326.                   if(_loopDelay < 0)
  327.                   {
  328.                      _frameSpeed = 1;
  329.                   }
  330.             }
  331.             cf = Math.floor(_currentFrame);
  332.             _bmd = _bmdArray[cf - 1];
  333.          }
  334.       }
  335.       
  336.       public function set Speed(inVal:Number) : *
  337.       {
  338.          _frameSpeed = inVal;
  339.       }
  340.       
  341.       public function get Type() : Number
  342.       {
  343.          return _objectType;
  344.       }
  345.       
  346.       public function playAnim() : *
  347.       {
  348.          _frameSpeed = 1;
  349.       }
  350.       
  351.       public function get AuditMeter() : Number
  352.       {
  353.          return _auditMeter;
  354.       }
  355.       
  356.       public function get CameraFocus() : Boolean
  357.       {
  358.          return _cameraFocus;
  359.       }
  360.       
  361.       public function get bmd() : BitmapData
  362.       {
  363.          return _bmd;
  364.       }
  365.       
  366.       public function collisionDraw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  367.       {
  368.          var rect:* = undefined;
  369.          var csx:Number = NaN;
  370.          var csy:Number = NaN;
  371.          var mtx:Number = NaN;
  372.          var mty:Number = NaN;
  373.          var pt:* = undefined;
  374.          if(!_collisionBitmap)
  375.          {
  376.             _collisionBitmap = new BitmapData(hitW,hitH,false,16711680);
  377.          }
  378.          rect = new Rectangle(0,0,_collisionBitmap.width,_collisionBitmap.height);
  379.          csx = s * (z / _scfl) * xflip;
  380.          csy = s * (z / _scfl) * yflip;
  381.          mtx = -inCamX * pxd * z + (x - _collisionBitmap.width / 2) + colOffsetX;
  382.          mty = -inCamY * pyd * z + (y - _collisionBitmap.height / 2) + colOffsetY;
  383.          pt = new Point(mtx,mty);
  384.          inBitmap.copyPixels(_collisionBitmap,rect,pt,null,null,false);
  385.       }
  386.       
  387.       public function get CollisionMethod() : Object
  388.       {
  389.          return _collisionMethod;
  390.       }
  391.       
  392.       public function findCollision(inBitmap:BitmapData, inColour:Number, inCamX:Number, inCamY:Number) : Boolean
  393.       {
  394.          var cbmd:BitmapData = null;
  395.          var csx:Number = NaN;
  396.          var csy:Number = NaN;
  397.          var mtx:Number = NaN;
  398.          var mty:Number = NaN;
  399.          var rect:* = undefined;
  400.          var pt:* = undefined;
  401.          var threshold:uint = 0;
  402.          var color:uint = 0;
  403.          var maskColor:uint = 0;
  404.          var numpx:uint = 0;
  405.          cbmd = new BitmapData(50,50,true,0);
  406.          csx = s * (z / _scfl) * xflip;
  407.          csy = s * (z / _scfl) * yflip;
  408.          mtx = -inCamX * pxd * z + (x - 25);
  409.          mty = -inCamY * pyd * z + (y - 25);
  410.          rect = new Rectangle(mtx,mty,50,50);
  411.          pt = new Point(0,0);
  412.          threshold = 16711680;
  413.          color = 16711680;
  414.          maskColor = 16711680;
  415.          numpx = cbmd.threshold(inBitmap,rect,pt,"==",threshold,color,maskColor,true);
  416.          if(numpx > 10)
  417.          {
  418.             return true;
  419.          }
  420.          return false;
  421.       }
  422.       
  423.       protected function slowDraw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  424.       {
  425.          var csx:Number = NaN;
  426.          var csy:Number = NaN;
  427.          var mtx:Number = NaN;
  428.          var mty:Number = NaN;
  429.          var ox:Number = NaN;
  430.          var oy:Number = NaN;
  431.          _matrix.identity();
  432.          csx = s * (z / _scfl) * xflip;
  433.          csy = s * (z / _scfl) * yflip;
  434.          if(r != 0)
  435.          {
  436.             ox = -w / 2 + roX;
  437.             oy = -h / 2 + roY;
  438.             _matrix.translate(ox,oy);
  439.             _matrix.rotate(r);
  440.             _matrix.translate(-ox,-oy);
  441.          }
  442.          if(!_lockScale)
  443.          {
  444.             if(s != 1 || z != 0)
  445.             {
  446.                _matrix.translate(-w / 2,-h / 2);
  447.                _matrix.scale(csx,csy);
  448.                _matrix.translate(w / 2,h / 2);
  449.             }
  450.          }
  451.          if(!lockX)
  452.          {
  453.             mtx = -inCamX * z + (x - w * csx / 2);
  454.          }
  455.          else
  456.          {
  457.             mtx = -inCamX * 1 + (x - w * csx / 2);
  458.          }
  459.          if(!lockY)
  460.          {
  461.             mty = -inCamY * z + (y - h * csy / 2);
  462.          }
  463.          else
  464.          {
  465.             mty = -inCamY * 1 + (y - h * csy / 2);
  466.          }
  467.          _matrix.translate(mtx,mty);
  468.          if(!_bmd)
  469.          {
  470.             trace("### ERROR _bmd is null - _currentFrame: " + _currentFrame);
  471.          }
  472.          inBitmap.draw(_bmd,_matrix,null,_blendMode,null,true);
  473.       }
  474.       
  475.       private function fastDraw(inBitmap:BitmapData, inCamX:Number, inCamY:Number) : *
  476.       {
  477.          var rect:* = undefined;
  478.          var mtx:Number = NaN;
  479.          var mty:Number = NaN;
  480.          var pt:* = undefined;
  481.          rect = new Rectangle(0,0,_bmd.width,_bmd.height);
  482.          if(!lockX)
  483.          {
  484.             mtx = -inCamX * pxd * z + (x - w / 2);
  485.          }
  486.          else
  487.          {
  488.             mtx = -inCamX * pxd * 1 + (x - w / 2);
  489.          }
  490.          if(!lockY)
  491.          {
  492.             mty = -inCamY * pyd * z + (y - h / 2);
  493.          }
  494.          else
  495.          {
  496.             mty = -inCamY * pyd * 1 + (y - h / 2);
  497.          }
  498.          pt = new Point(Math.floor(mtx),Math.floor(mty));
  499.          inBitmap.copyPixels(_bmd,rect,pt,null,null,true);
  500.       }
  501.       
  502.       public function destroy() : *
  503.       {
  504.          if(_objectType == -1)
  505.          {
  506.             trace("### ERROR Object type not defined on: " + this + " _objectType: " + _objectType);
  507.          }
  508.          switch(_objectType)
  509.          {
  510.             case OBJ_TYPES.FX:
  511.                WorldScene.Instance.clearFX(this);
  512.                break;
  513.             case OBJ_TYPES.GP:
  514.                WorldScene.Instance.clearGPObject(this);
  515.          }
  516.          destroyed = true;
  517.       }
  518.       
  519.       public function get CMethods() : Object
  520.       {
  521.          return COLLISION_METHOD;
  522.       }
  523.    }
  524. }
  525.